home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / sre_compile.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  11KB  |  491 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. import sre_parse
  8. from sre_constants import *
  9. if not _sre.MAGIC == MAGIC:
  10.     raise AssertionError, 'SRE module mismatch'
  11. if _sre.CODESIZE == 2:
  12.     MAXCODE = 65535
  13. else:
  14.     MAXCODE = 0xFFFFFFFFL
  15.  
  16. def _identityfunction(x):
  17.     return x
  18.  
  19.  
  20. def set(seq):
  21.     s = { }
  22.     for elem in seq:
  23.         s[elem] = 1
  24.     
  25.     return s
  26.  
  27. _LITERAL_CODES = set([
  28.     LITERAL,
  29.     NOT_LITERAL])
  30. _REPEATING_CODES = set([
  31.     REPEAT,
  32.     MIN_REPEAT,
  33.     MAX_REPEAT])
  34. _SUCCESS_CODES = set([
  35.     SUCCESS,
  36.     FAILURE])
  37. _ASSERT_CODES = set([
  38.     ASSERT,
  39.     ASSERT_NOT])
  40.  
  41. def _compile(code, pattern, flags):
  42.     emit = code.append
  43.     _len = len
  44.     LITERAL_CODES = _LITERAL_CODES
  45.     REPEATING_CODES = _REPEATING_CODES
  46.     SUCCESS_CODES = _SUCCESS_CODES
  47.     ASSERT_CODES = _ASSERT_CODES
  48.     for op, av in pattern:
  49.         if op in LITERAL_CODES:
  50.             if flags & SRE_FLAG_IGNORECASE:
  51.                 emit(OPCODES[OP_IGNORE[op]])
  52.                 emit(_sre.getlower(av, flags))
  53.             else:
  54.                 emit(OPCODES[op])
  55.                 emit(av)
  56.         flags & SRE_FLAG_IGNORECASE
  57.         None if op is IN else flags & SRE_FLAG_DOTALL
  58.         if op in REPEATING_CODES:
  59.             if flags & SRE_FLAG_TEMPLATE:
  60.                 raise error, 'internal: unsupported template operator'
  61.             flags & SRE_FLAG_TEMPLATE(OPCODES[REPEAT])
  62.             skip = _len(code)
  63.             emit(0)
  64.             emit(av[0])
  65.             emit(av[1])
  66.             _compile(code, av[2], flags)
  67.             emit(OPCODES[SUCCESS])
  68.             code[skip] = _len(code) - skip
  69.         elif _simple(av) and op is not REPEAT:
  70.             if op is MAX_REPEAT:
  71.                 emit(OPCODES[REPEAT_ONE])
  72.             else:
  73.                 emit(OPCODES[MIN_REPEAT_ONE])
  74.             skip = _len(code)
  75.             emit(0)
  76.             emit(av[0])
  77.             emit(av[1])
  78.             _compile(code, av[2], flags)
  79.             emit(OPCODES[SUCCESS])
  80.             code[skip] = _len(code) - skip
  81.         else:
  82.             emit(OPCODES[REPEAT])
  83.             skip = _len(code)
  84.             emit(0)
  85.             emit(av[0])
  86.             emit(av[1])
  87.             _compile(code, av[2], flags)
  88.             code[skip] = _len(code) - skip
  89.             if op is MAX_REPEAT:
  90.                 emit(OPCODES[MAX_UNTIL])
  91.             else:
  92.                 emit(OPCODES[MIN_UNTIL])
  93.             op is MAX_REPEAT
  94.             if op is SUBPATTERN:
  95.                 if av[0]:
  96.                     emit(OPCODES[MARK])
  97.                     emit((av[0] - 1) * 2)
  98.                 
  99.                 _compile(code, av[1], flags)
  100.                 if av[0]:
  101.                     emit(OPCODES[MARK])
  102.                     emit((av[0] - 1) * 2 + 1)
  103.                 
  104.             av[0]
  105.             if op in SUCCESS_CODES:
  106.                 emit(OPCODES[op])
  107.                 continue
  108.             if op in ASSERT_CODES:
  109.                 emit(OPCODES[op])
  110.                 skip = _len(code)
  111.                 emit(0)
  112.                 if av[0] >= 0:
  113.                     emit(0)
  114.                 else:
  115.                     (lo, hi) = av[1].getwidth()
  116.                     if lo != hi:
  117.                         raise error, 'look-behind requires fixed-width pattern'
  118.                     lo != hi
  119.                     emit(lo)
  120.                 _compile(code, av[1], flags)
  121.                 emit(OPCODES[SUCCESS])
  122.                 code[skip] = _len(code) - skip
  123.                 continue
  124.             if op is CALL:
  125.                 emit(OPCODES[op])
  126.                 skip = _len(code)
  127.                 emit(0)
  128.                 _compile(code, av, flags)
  129.                 emit(OPCODES[SUCCESS])
  130.                 code[skip] = _len(code) - skip
  131.                 continue
  132.             if op is AT:
  133.                 emit(OPCODES[op])
  134.                 if flags & SRE_FLAG_MULTILINE:
  135.                     av = AT_MULTILINE.get(av, av)
  136.                 
  137.                 if flags & SRE_FLAG_LOCALE:
  138.                     av = AT_LOCALE.get(av, av)
  139.                 elif flags & SRE_FLAG_UNICODE:
  140.                     av = AT_UNICODE.get(av, av)
  141.                 
  142.                 emit(ATCODES[av])
  143.                 continue
  144.             if op is BRANCH:
  145.                 emit(OPCODES[op])
  146.                 tail = []
  147.                 tailappend = tail.append
  148.                 for av in av[1]:
  149.                     skip = _len(code)
  150.                     emit(0)
  151.                     _compile(code, av, flags)
  152.                     emit(OPCODES[JUMP])
  153.                     tailappend(_len(code))
  154.                     emit(0)
  155.                     code[skip] = _len(code) - skip
  156.                 
  157.                 emit(0)
  158.                 for tail in tail:
  159.                     code[tail] = _len(code) - tail
  160.                 
  161.             if op is CATEGORY:
  162.                 emit(OPCODES[op])
  163.                 if flags & SRE_FLAG_LOCALE:
  164.                     av = CH_LOCALE[av]
  165.                 elif flags & SRE_FLAG_UNICODE:
  166.                     av = CH_UNICODE[av]
  167.                 
  168.                 emit(CHCODES[av])
  169.                 continue
  170.             None if op is GROUPREF else av[2]
  171.             raise ValueError, ('unsupported operand type', op)
  172.     
  173.  
  174.  
  175. def _compile_charset(charset, flags, code, fixup = None):
  176.     emit = code.append
  177.     if fixup is None:
  178.         fixup = _identityfunction
  179.     
  180.     for op, av in _optimize_charset(charset, fixup):
  181.         emit(OPCODES[op])
  182.         if op is NEGATE:
  183.             continue
  184.         if op is LITERAL:
  185.             emit(fixup(av))
  186.             continue
  187.         if op is RANGE:
  188.             emit(fixup(av[0]))
  189.             emit(fixup(av[1]))
  190.             continue
  191.         if op is CHARSET:
  192.             code.extend(av)
  193.             continue
  194.         None if op is BIGCHARSET else flags & SRE_FLAG_LOCALE
  195.         raise error, 'internal: unsupported set operator'
  196.     
  197.     emit(OPCODES[FAILURE])
  198.  
  199.  
  200. def _optimize_charset(charset, fixup):
  201.     out = []
  202.     outappend = out.append
  203.     charmap = [
  204.         0] * 256
  205.     
  206.     try:
  207.         for op, av in charset:
  208.             if op is NEGATE:
  209.                 outappend((op, av))
  210.                 continue
  211.             if op is LITERAL:
  212.                 charmap[fixup(av)] = 1
  213.                 continue
  214.             if op is RANGE:
  215.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  216.                     charmap[i] = 1
  217.                 
  218.             if op is CATEGORY:
  219.                 return charset
  220.     except IndexError:
  221.         return _optimize_unicode(charset, fixup)
  222.  
  223.     i = p = n = 0
  224.     runs = []
  225.     runsappend = runs.append
  226.     for c in charmap:
  227.         if c:
  228.             if n == 0:
  229.                 p = i
  230.             
  231.             n = n + 1
  232.         elif n:
  233.             runsappend((p, n))
  234.             n = 0
  235.         
  236.         i = i + 1
  237.     
  238.     if n:
  239.         runsappend((p, n))
  240.     
  241.     if len(runs) <= 2:
  242.         for p, n in runs:
  243.             if n == 1:
  244.                 outappend((LITERAL, p))
  245.                 continue
  246.             outappend((RANGE, (p, p + n - 1)))
  247.         
  248.         if len(out) < len(charset):
  249.             return out
  250.     else:
  251.         data = _mk_bitmap(charmap)
  252.         outappend((CHARSET, data))
  253.         return out
  254.     return len(out) < len(charset)
  255.  
  256.  
  257. def _mk_bitmap(bits):
  258.     data = []
  259.     dataappend = data.append
  260.     if _sre.CODESIZE == 2:
  261.         start = (1, 0)
  262.     else:
  263.         start = (0x1L, 0x0L)
  264.     (m, v) = start
  265.     for c in bits:
  266.         if c:
  267.             v = v + m
  268.         
  269.         m = m + m
  270.         if m > MAXCODE:
  271.             dataappend(v)
  272.             (m, v) = start
  273.             continue
  274.     
  275.     return data
  276.  
  277.  
  278. def _optimize_unicode(charset, fixup):
  279.     
  280.     try:
  281.         import array as array
  282.     except ImportError:
  283.         return charset
  284.  
  285.     charmap = [
  286.         0] * 65536
  287.     negate = 0
  288.     
  289.     try:
  290.         for op, av in charset:
  291.             if op is NEGATE:
  292.                 negate = 1
  293.                 continue
  294.             if op is LITERAL:
  295.                 charmap[fixup(av)] = 1
  296.                 continue
  297.             if op is RANGE:
  298.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  299.                     charmap[i] = 1
  300.                 
  301.             if op is CATEGORY:
  302.                 return charset
  303.     except IndexError:
  304.         return charset
  305.  
  306.     if negate:
  307.         if sys.maxunicode != 65535:
  308.             return charset
  309.         for i in xrange(65536):
  310.             charmap[i] = not charmap[i]
  311.         
  312.     
  313.     comps = { }
  314.     mapping = [
  315.         0] * 256
  316.     block = 0
  317.     data = []
  318.     for i in xrange(256):
  319.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  320.         new = comps.setdefault(chunk, block)
  321.         mapping[i] = new
  322.         if new == block:
  323.             block = block + 1
  324.             data = data + _mk_bitmap(chunk)
  325.             continue
  326.     
  327.     header = [
  328.         block]
  329.     if _sre.CODESIZE == 2:
  330.         code = 'H'
  331.     else:
  332.         code = 'I'
  333.     mapping = array.array('b', mapping).tostring()
  334.     mapping = array.array(code, mapping)
  335.     if not mapping.itemsize == _sre.CODESIZE:
  336.         raise AssertionError
  337.     header = header + mapping.tolist()
  338.     data[0:0] = header
  339.     return [
  340.         (BIGCHARSET, data)]
  341.  
  342.  
  343. def _simple(av):
  344.     (lo, hi) = av[2].getwidth()
  345.     if lo == 0 and hi == MAXREPEAT:
  346.         raise error, 'nothing to repeat'
  347.     hi == MAXREPEAT
  348.     return None if hi == hi else av[2][0][0] != SUBPATTERN
  349.  
  350.  
  351. def _compile_info(code, pattern, flags):
  352.     (lo, hi) = pattern.getwidth()
  353.     if lo == 0:
  354.         return None
  355.     prefix = []
  356.     prefixappend = prefix.append
  357.     prefix_skip = 0
  358.     charset = []
  359.     charsetappend = charset.append
  360.     if not flags & SRE_FLAG_IGNORECASE:
  361.         for op, av in pattern.data:
  362.             None if op is LITERAL else op is LITERAL
  363.             break
  364.         
  365.         if not prefix and pattern.data:
  366.             (op, av) = pattern.data[0]
  367.             if op is SUBPATTERN and av[1]:
  368.                 (op, av) = av[1][0]
  369.                 if op is LITERAL:
  370.                     charsetappend((op, av))
  371.                 elif op is BRANCH:
  372.                     c = []
  373.                     cappend = c.append
  374.                     for p in av[1]:
  375.                         if not p:
  376.                             break
  377.                         
  378.                         (op, av) = p[0]
  379.                         if op is LITERAL:
  380.                             cappend((op, av))
  381.                             continue
  382.                         break
  383.                     else:
  384.                         charset = c
  385.                 
  386.             elif op is BRANCH:
  387.                 c = []
  388.                 cappend = c.append
  389.                 for p in av[1]:
  390.                     if not p:
  391.                         break
  392.                     
  393.                     (op, av) = p[0]
  394.                     if op is LITERAL:
  395.                         cappend((op, av))
  396.                         continue
  397.                     break
  398.                 else:
  399.                     charset = c
  400.             elif op is IN:
  401.                 charset = av
  402.             
  403.         
  404.     
  405.     emit = code.append
  406.     emit(OPCODES[INFO])
  407.     skip = len(code)
  408.     emit(0)
  409.     mask = 0
  410.     if prefix:
  411.         mask = SRE_INFO_PREFIX
  412.         if prefix_skip == prefix_skip:
  413.             pass
  414.         elif prefix_skip == len(pattern.data):
  415.             mask = mask + SRE_INFO_LITERAL
  416.         
  417.     elif charset:
  418.         mask = mask + SRE_INFO_CHARSET
  419.     
  420.     emit(mask)
  421.     if lo < MAXCODE:
  422.         emit(lo)
  423.     else:
  424.         emit(MAXCODE)
  425.         prefix = prefix[:MAXCODE]
  426.     if hi < MAXCODE:
  427.         emit(hi)
  428.     else:
  429.         emit(0)
  430.     if prefix:
  431.         emit(len(prefix))
  432.         emit(prefix_skip)
  433.         code.extend(prefix)
  434.         table = [
  435.             -1] + [
  436.             0] * len(prefix)
  437.         for i in xrange(len(prefix)):
  438.             table[i + 1] = table[i] + 1
  439.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  440.                 table[i + 1] = table[table[i + 1] - 1] + 1
  441.         
  442.         code.extend(table[1:])
  443.     elif charset:
  444.         _compile_charset(charset, flags, code)
  445.     
  446.     code[skip] = len(code) - skip
  447.  
  448.  
  449. try:
  450.     unicode
  451. except NameError:
  452.     STRING_TYPES = (type(''),)
  453.  
  454. STRING_TYPES = (type(''), type(unicode('')))
  455.  
  456. def isstring(obj):
  457.     for tp in STRING_TYPES:
  458.         if isinstance(obj, tp):
  459.             return 1
  460.     
  461.     return 0
  462.  
  463.  
  464. def _code(p, flags):
  465.     flags = p.pattern.flags | flags
  466.     code = []
  467.     _compile_info(code, p, flags)
  468.     _compile(code, p.data, flags)
  469.     code.append(OPCODES[SUCCESS])
  470.     return code
  471.  
  472.  
  473. def compile(p, flags = 0):
  474.     if isstring(p):
  475.         pattern = p
  476.         p = sre_parse.parse(p, flags)
  477.     else:
  478.         pattern = None
  479.     code = _code(p, flags)
  480.     if p.pattern.groups > 100:
  481.         raise AssertionError('sorry, but this version only supports 100 named groups')
  482.     p.pattern.groups > 100
  483.     groupindex = p.pattern.groupdict
  484.     indexgroup = [
  485.         None] * p.pattern.groups
  486.     for k, i in groupindex.items():
  487.         indexgroup[i] = k
  488.     
  489.     return _sre.compile(pattern, flags | p.pattern.flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  490.  
  491.